var IVSDrawer_Module = (function () {
	var _scriptDir = typeof document !== 'undefined' && document.currentScript ? document.currentScript.src : undefined;
	if (typeof __filename !== 'undefined') _scriptDir = _scriptDir || __filename;
	return function (IVSDrawer_Module) {
		IVSDrawer_Module = IVSDrawer_Module || {};

		var Module = typeof IVSDrawer_Module !== 'undefined' ? IVSDrawer_Module : {};
		var readyPromiseResolve, readyPromiseReject;
		Module['ready'] = new Promise(function (resolve, reject) {
			readyPromiseResolve = resolve;
			readyPromiseReject = reject;
		});
		var moduleOverrides = {};
		var key;
		for (key in Module) {
			if (Module.hasOwnProperty(key)) {
				moduleOverrides[key] = Module[key];
			}
		}
		var arguments_ = [];
		var thisProgram = './this.program';
		var quit_ = function (status, toThrow) {
			throw toThrow;
		};
		var ENVIRONMENT_IS_WEB = false;
		var ENVIRONMENT_IS_WORKER = false;
		var ENVIRONMENT_IS_NODE = false;
		var ENVIRONMENT_IS_SHELL = false;
		ENVIRONMENT_IS_WEB = typeof window === 'object';
		ENVIRONMENT_IS_WORKER = typeof importScripts === 'function';
		ENVIRONMENT_IS_NODE = typeof process === 'object' && typeof process.versions === 'object' && typeof process.versions.node === 'string';
		ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;
		var scriptDirectory = '';
		function locateFile(path) {
			if (Module['locateFile']) {
				return Module['locateFile'](path, scriptDirectory);
			}
			return scriptDirectory + path;
		}
		var read_, readAsync, readBinary, setWindowTitle;
		var nodeFS;
		var nodePath;
		if (ENVIRONMENT_IS_NODE) {
			if (ENVIRONMENT_IS_WORKER) {
				scriptDirectory = require('path').dirname(scriptDirectory) + '/';
			} else {
				scriptDirectory = __dirname + '/';
			}
			read_ = function shell_read(filename, binary) {
				if (!nodeFS) nodeFS = require('fs');
				if (!nodePath) nodePath = require('path');
				filename = nodePath['normalize'](filename);
				return nodeFS['readFileSync'](filename, binary ? null : 'utf8');
			};
			readBinary = function readBinary(filename) {
				var ret = read_(filename, true);
				if (!ret.buffer) {
					ret = new Uint8Array(ret);
				}
				assert(ret.buffer);
				return ret;
			};
			if (process['argv'].length > 1) {
				thisProgram = process['argv'][1].replace(/\\/g, '/');
			}
			arguments_ = process['argv'].slice(2);
			process['on']('uncaughtException', function (ex) {
				if (!(ex instanceof ExitStatus)) {
					throw ex;
				}
			});
			process['on']('unhandledRejection', abort);
			quit_ = function (status) {
				process['exit'](status);
			};
			Module['inspect'] = function () {
				return '[Emscripten Module object]';
			};
		} else if (ENVIRONMENT_IS_SHELL) {
			if (typeof read != 'undefined') {
				read_ = function shell_read(f) {
					return read(f);
				};
			}
			readBinary = function readBinary(f) {
				var data;
				if (typeof readbuffer === 'function') {
					return new Uint8Array(readbuffer(f));
				}
				data = read(f, 'binary');
				assert(typeof data === 'object');
				return data;
			};
			if (typeof scriptArgs != 'undefined') {
				arguments_ = scriptArgs;
			} else if (typeof arguments != 'undefined') {
				arguments_ = arguments;
			}
			if (typeof quit === 'function') {
				quit_ = function (status) {
					quit(status);
				};
			}
			if (typeof print !== 'undefined') {
				if (typeof console === 'undefined') console = {};
				console.log = print;
				console.warn = console.error = typeof printErr !== 'undefined' ? printErr : print;
			}
		} else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
			if (ENVIRONMENT_IS_WORKER) {
				scriptDirectory = self.location.href;
			} else if (typeof document !== 'undefined' && document.currentScript) {
				scriptDirectory = document.currentScript.src;
			}
			if (_scriptDir) {
				scriptDirectory = _scriptDir;
			}
			if (scriptDirectory.indexOf('blob:') !== 0) {
				scriptDirectory = scriptDirectory.substr(0, scriptDirectory.lastIndexOf('/') + 1);
			} else {
				scriptDirectory = '';
			}
			{
				read_ = function (url) {
					var xhr = new XMLHttpRequest();
					xhr.open('GET', url, false);
					xhr.send(null);
					return xhr.responseText;
				};
				if (ENVIRONMENT_IS_WORKER) {
					readBinary = function (url) {
						var xhr = new XMLHttpRequest();
						xhr.open('GET', url, false);
						xhr.responseType = 'arraybuffer';
						xhr.send(null);
						return new Uint8Array(xhr.response);
					};
				}
				readAsync = function (url, onload, onerror) {
					var xhr = new XMLHttpRequest();
					xhr.open('GET', url, true);
					xhr.responseType = 'arraybuffer';
					xhr.onload = function () {
						if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) {
							onload(xhr.response);
							return;
						}
						onerror();
					};
					xhr.onerror = onerror;
					xhr.send(null);
				};
			}
			setWindowTitle = function (title) {
				document.title = title;
			};
		} else {
		}
		var out = Module['print'] || console.log.bind(console);
		var err = Module['printErr'] || console.warn.bind(console);
		for (key in moduleOverrides) {
			if (moduleOverrides.hasOwnProperty(key)) {
				Module[key] = moduleOverrides[key];
			}
		}
		moduleOverrides = null;
		if (Module['arguments']) arguments_ = Module['arguments'];
		if (Module['thisProgram']) thisProgram = Module['thisProgram'];
		if (Module['quit']) quit_ = Module['quit'];
		var tempRet0 = 0;
		var setTempRet0 = function (value) {
			tempRet0 = value;
		};
		var getTempRet0 = function () {
			return tempRet0;
		};
		var wasmBinary;
		if (Module['wasmBinary']) wasmBinary = Module['wasmBinary'];
		var noExitRuntime = Module['noExitRuntime'] || true;
		if (typeof WebAssembly !== 'object') {
			abort('no native wasm support detected');
		}
		var wasmMemory;
		var ABORT = false;
		var EXITSTATUS;
		function assert(condition, text) {
			if (!condition) {
				abort('Assertion failed: ' + text);
			}
		}
		var UTF8Decoder = typeof TextDecoder !== 'undefined' ? new TextDecoder('utf8') : undefined;
		function UTF8ArrayToString(heap, idx, maxBytesToRead) {
			var endIdx = idx + maxBytesToRead;
			var endPtr = idx;
			while (heap[endPtr] && !(endPtr >= endIdx)) ++endPtr;
			if (endPtr - idx > 16 && heap.subarray && UTF8Decoder) {
				return UTF8Decoder.decode(heap.subarray(idx, endPtr));
			} else {
				var str = '';
				while (idx < endPtr) {
					var u0 = heap[idx++];
					if (!(u0 & 128)) {
						str += String.fromCharCode(u0);
						continue;
					}
					var u1 = heap[idx++] & 63;
					if ((u0 & 224) == 192) {
						str += String.fromCharCode(((u0 & 31) << 6) | u1);
						continue;
					}
					var u2 = heap[idx++] & 63;
					if ((u0 & 240) == 224) {
						u0 = ((u0 & 15) << 12) | (u1 << 6) | u2;
					} else {
						u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (heap[idx++] & 63);
					}
					if (u0 < 65536) {
						str += String.fromCharCode(u0);
					} else {
						var ch = u0 - 65536;
						str += String.fromCharCode(55296 | (ch >> 10), 56320 | (ch & 1023));
					}
				}
			}
			return str;
		}
		function UTF8ToString(ptr, maxBytesToRead) {
			return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : '';
		}
		function stringToUTF8Array(str, heap, outIdx, maxBytesToWrite) {
			if (!(maxBytesToWrite > 0)) return 0;
			var startIdx = outIdx;
			var endIdx = outIdx + maxBytesToWrite - 1;
			for (var i = 0; i < str.length; ++i) {
				var u = str.charCodeAt(i);
				if (u >= 55296 && u <= 57343) {
					var u1 = str.charCodeAt(++i);
					u = (65536 + ((u & 1023) << 10)) | (u1 & 1023);
				}
				if (u <= 127) {
					if (outIdx >= endIdx) break;
					heap[outIdx++] = u;
				} else if (u <= 2047) {
					if (outIdx + 1 >= endIdx) break;
					heap[outIdx++] = 192 | (u >> 6);
					heap[outIdx++] = 128 | (u & 63);
				} else if (u <= 65535) {
					if (outIdx + 2 >= endIdx) break;
					heap[outIdx++] = 224 | (u >> 12);
					heap[outIdx++] = 128 | ((u >> 6) & 63);
					heap[outIdx++] = 128 | (u & 63);
				} else {
					if (outIdx + 3 >= endIdx) break;
					heap[outIdx++] = 240 | (u >> 18);
					heap[outIdx++] = 128 | ((u >> 12) & 63);
					heap[outIdx++] = 128 | ((u >> 6) & 63);
					heap[outIdx++] = 128 | (u & 63);
				}
			}
			heap[outIdx] = 0;
			return outIdx - startIdx;
		}
		function lengthBytesUTF8(str) {
			var len = 0;
			for (var i = 0; i < str.length; ++i) {
				var u = str.charCodeAt(i);
				if (u >= 55296 && u <= 57343) u = (65536 + ((u & 1023) << 10)) | (str.charCodeAt(++i) & 1023);
				if (u <= 127) ++len;
				else if (u <= 2047) len += 2;
				else if (u <= 65535) len += 3;
				else len += 4;
			}
			return len;
		}
		function allocateUTF8(str) {
			var size = lengthBytesUTF8(str) + 1;
			var ret = _malloc(size);
			if (ret) stringToUTF8Array(str, HEAP8, ret, size);
			return ret;
		}
		function writeArrayToMemory(array, buffer) {
			HEAP8.set(array, buffer);
		}
		function writeAsciiToMemory(str, buffer, dontAddNull) {
			for (var i = 0; i < str.length; ++i) {
				HEAP8[buffer++ >> 0] = str.charCodeAt(i);
			}
			if (!dontAddNull) HEAP8[buffer >> 0] = 0;
		}
		var buffer, HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
		function updateGlobalBufferAndViews(buf) {
			buffer = buf;
			Module['HEAP8'] = HEAP8 = new Int8Array(buf);
			Module['HEAP16'] = HEAP16 = new Int16Array(buf);
			Module['HEAP32'] = HEAP32 = new Int32Array(buf);
			Module['HEAPU8'] = HEAPU8 = new Uint8Array(buf);
			Module['HEAPU16'] = HEAPU16 = new Uint16Array(buf);
			Module['HEAPU32'] = HEAPU32 = new Uint32Array(buf);
			Module['HEAPF32'] = HEAPF32 = new Float32Array(buf);
			Module['HEAPF64'] = HEAPF64 = new Float64Array(buf);
		}
		var INITIAL_MEMORY = Module['INITIAL_MEMORY'] || 16777216;
		var wasmTable;
		var __ATPRERUN__ = [];
		var __ATINIT__ = [];
		var __ATMAIN__ = [];
		var __ATPOSTRUN__ = [];
		var runtimeInitialized = false;
		__ATINIT__.push({
			func: function () {
				___wasm_call_ctors();
			},
		});
		function preRun() {
			if (Module['preRun']) {
				if (typeof Module['preRun'] == 'function') Module['preRun'] = [Module['preRun']];
				while (Module['preRun'].length) {
					addOnPreRun(Module['preRun'].shift());
				}
			}
			callRuntimeCallbacks(__ATPRERUN__);
		}
		function initRuntime() {
			runtimeInitialized = true;
			callRuntimeCallbacks(__ATINIT__);
		}
		function preMain() {
			callRuntimeCallbacks(__ATMAIN__);
		}
		function postRun() {
			if (Module['postRun']) {
				if (typeof Module['postRun'] == 'function') Module['postRun'] = [Module['postRun']];
				while (Module['postRun'].length) {
					addOnPostRun(Module['postRun'].shift());
				}
			}
			callRuntimeCallbacks(__ATPOSTRUN__);
		}
		function addOnPreRun(cb) {
			__ATPRERUN__.unshift(cb);
		}
		function addOnPostRun(cb) {
			__ATPOSTRUN__.unshift(cb);
		}
		var runDependencies = 0;
		var runDependencyWatcher = null;
		var dependenciesFulfilled = null;
		function addRunDependency(id) {
			runDependencies++;
			if (Module['monitorRunDependencies']) {
				Module['monitorRunDependencies'](runDependencies);
			}
		}
		function removeRunDependency(id) {
			runDependencies--;
			if (Module['monitorRunDependencies']) {
				Module['monitorRunDependencies'](runDependencies);
			}
			if (runDependencies == 0) {
				if (runDependencyWatcher !== null) {
					clearInterval(runDependencyWatcher);
					runDependencyWatcher = null;
				}
				if (dependenciesFulfilled) {
					var callback = dependenciesFulfilled;
					dependenciesFulfilled = null;
					callback();
				}
			}
		}
		Module['preloadedImages'] = {};
		Module['preloadedAudios'] = {};
		function abort(what) {
			if (Module['onAbort']) {
				Module['onAbort'](what);
			}
			what += '';
			err(what);
			ABORT = true;
			EXITSTATUS = 1;
			what = 'abort(' + what + '). Build with -s ASSERTIONS=1 for more info.';
			var e = new WebAssembly.RuntimeError(what);
			readyPromiseReject(e);
			throw e;
		}
		function hasPrefix(str, prefix) {
			return String.prototype.startsWith ? str.startsWith(prefix) : str.indexOf(prefix) === 0;
		}
		var dataURIPrefix = 'data:application/octet-stream;base64,';
		function isDataURI(filename) {
			return hasPrefix(filename, dataURIPrefix);
		}
		var fileURIPrefix = 'file://';
		function isFileURI(filename) {
			return hasPrefix(filename, fileURIPrefix);
		}
		var wasmBinaryFile = 'libIVSDrawer.wasm';
		if (!isDataURI(wasmBinaryFile)) {
			wasmBinaryFile = locateFile(wasmBinaryFile);
		}
		function getBinary(file) {
			try {
				if (file == wasmBinaryFile && wasmBinary) {
					return new Uint8Array(wasmBinary);
				}
				if (readBinary) {
					return readBinary(file);
				} else {
					throw 'both async and sync fetching of the wasm failed';
				}
			} catch (err) {
				abort(err);
			}
		}
		function getBinaryPromise() {
			if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER)) {
				if (typeof fetch === 'function' && !isFileURI(wasmBinaryFile)) {
					return fetch(wasmBinaryFile, { credentials: 'same-origin' })
						.then(function (response) {
							if (!response['ok']) {
								throw "failed to load wasm binary file at '" + wasmBinaryFile + "'";
							}
							return response['arrayBuffer']();
						})
						.catch(function () {
							return getBinary(wasmBinaryFile);
						});
				} else {
					if (readAsync) {
						return new Promise(function (resolve, reject) {
							readAsync(
								wasmBinaryFile,
								function (response) {
									resolve(new Uint8Array(response));
								},
								reject
							);
						});
					}
				}
			}
			return Promise.resolve().then(function () {
				return getBinary(wasmBinaryFile);
			});
		}
		function createWasm() {
			var info = { a: asmLibraryArg };
			function receiveInstance(instance, module) {
				var exports = instance.exports;
				Module['asm'] = exports;
				wasmMemory = Module['asm']['ka'];
				updateGlobalBufferAndViews(wasmMemory.buffer);
				wasmTable = Module['asm']['Na'];
				removeRunDependency('wasm-instantiate');
			}
			addRunDependency('wasm-instantiate');
			function receiveInstantiatedSource(output) {
				receiveInstance(output['instance']);
			}
			function instantiateArrayBuffer(receiver) {
				return getBinaryPromise()
					.then(function (binary) {
						return WebAssembly.instantiate(binary, info);
					})
					.then(receiver, function (reason) {
						err('failed to asynchronously prepare wasm: ' + reason);
						abort(reason);
					});
			}
			function instantiateAsync() {
				if (
					!wasmBinary &&
					typeof WebAssembly.instantiateStreaming === 'function' &&
					!isDataURI(wasmBinaryFile) &&
					!isFileURI(wasmBinaryFile) &&
					typeof fetch === 'function'
				) {
					return fetch(wasmBinaryFile, { credentials: 'same-origin' }).then(function (response) {
						var result = WebAssembly.instantiateStreaming(response, info);
						return result.then(receiveInstantiatedSource, function (reason) {
							err('wasm streaming compile failed: ' + reason);
							err('falling back to ArrayBuffer instantiation');
							return instantiateArrayBuffer(receiveInstantiatedSource);
						});
					});
				} else {
					return instantiateArrayBuffer(receiveInstantiatedSource);
				}
			}
			if (Module['instantiateWasm']) {
				try {
					var exports = Module['instantiateWasm'](info, receiveInstance);
					return exports;
				} catch (e) {
					err('Module.instantiateWasm callback failed with error: ' + e);
					return false;
				}
			}
			instantiateAsync().catch(readyPromiseReject);
			return {};
		}
		function callRuntimeCallbacks(callbacks) {
			while (callbacks.length > 0) {
				var callback = callbacks.shift();
				if (typeof callback == 'function') {
					callback(Module);
					continue;
				}
				var func = callback.func;
				if (typeof func === 'number') {
					if (callback.arg === undefined) {
						wasmTable.get(func)();
					} else {
						wasmTable.get(func)(callback.arg);
					}
				} else {
					func(callback.arg === undefined ? null : callback.arg);
				}
			}
		}
		function ___assert_fail(condition, filename, line, func) {
			abort(
				'Assertion failed: ' +
					UTF8ToString(condition) +
					', at: ' +
					[filename ? UTF8ToString(filename) : 'unknown filename', line, func ? UTF8ToString(func) : 'unknown function']
			);
		}
		var ExceptionInfoAttrs = { DESTRUCTOR_OFFSET: 0, REFCOUNT_OFFSET: 4, TYPE_OFFSET: 8, CAUGHT_OFFSET: 12, RETHROWN_OFFSET: 13, SIZE: 16 };
		function ___cxa_allocate_exception(size) {
			return _malloc(size + ExceptionInfoAttrs.SIZE) + ExceptionInfoAttrs.SIZE;
		}
		function ExceptionInfo(excPtr) {
			this.excPtr = excPtr;
			this.ptr = excPtr - ExceptionInfoAttrs.SIZE;
			this.set_type = function (type) {
				HEAP32[(this.ptr + ExceptionInfoAttrs.TYPE_OFFSET) >> 2] = type;
			};
			this.get_type = function () {
				return HEAP32[(this.ptr + ExceptionInfoAttrs.TYPE_OFFSET) >> 2];
			};
			this.set_destructor = function (destructor) {
				HEAP32[(this.ptr + ExceptionInfoAttrs.DESTRUCTOR_OFFSET) >> 2] = destructor;
			};
			this.get_destructor = function () {
				return HEAP32[(this.ptr + ExceptionInfoAttrs.DESTRUCTOR_OFFSET) >> 2];
			};
			this.set_refcount = function (refcount) {
				HEAP32[(this.ptr + ExceptionInfoAttrs.REFCOUNT_OFFSET) >> 2] = refcount;
			};
			this.set_caught = function (caught) {
				caught = caught ? 1 : 0;
				HEAP8[(this.ptr + ExceptionInfoAttrs.CAUGHT_OFFSET) >> 0] = caught;
			};
			this.get_caught = function () {
				return HEAP8[(this.ptr + ExceptionInfoAttrs.CAUGHT_OFFSET) >> 0] != 0;
			};
			this.set_rethrown = function (rethrown) {
				rethrown = rethrown ? 1 : 0;
				HEAP8[(this.ptr + ExceptionInfoAttrs.RETHROWN_OFFSET) >> 0] = rethrown;
			};
			this.get_rethrown = function () {
				return HEAP8[(this.ptr + ExceptionInfoAttrs.RETHROWN_OFFSET) >> 0] != 0;
			};
			this.init = function (type, destructor) {
				this.set_type(type);
				this.set_destructor(destructor);
				this.set_refcount(0);
				this.set_caught(false);
				this.set_rethrown(false);
			};
			this.add_ref = function () {
				var value = HEAP32[(this.ptr + ExceptionInfoAttrs.REFCOUNT_OFFSET) >> 2];
				HEAP32[(this.ptr + ExceptionInfoAttrs.REFCOUNT_OFFSET) >> 2] = value + 1;
			};
			this.release_ref = function () {
				var prev = HEAP32[(this.ptr + ExceptionInfoAttrs.REFCOUNT_OFFSET) >> 2];
				HEAP32[(this.ptr + ExceptionInfoAttrs.REFCOUNT_OFFSET) >> 2] = prev - 1;
				return prev === 1;
			};
		}
		function CatchInfo(ptr) {
			this.free = function () {
				_free(this.ptr);
				this.ptr = 0;
			};
			this.set_base_ptr = function (basePtr) {
				HEAP32[this.ptr >> 2] = basePtr;
			};
			this.get_base_ptr = function () {
				return HEAP32[this.ptr >> 2];
			};
			this.set_adjusted_ptr = function (adjustedPtr) {
				var ptrSize = 4;
				HEAP32[(this.ptr + ptrSize) >> 2] = adjustedPtr;
			};
			this.get_adjusted_ptr = function () {
				var ptrSize = 4;
				return HEAP32[(this.ptr + ptrSize) >> 2];
			};
			this.get_exception_ptr = function () {
				var isPointer = ___cxa_is_pointer_type(this.get_exception_info().get_type());
				if (isPointer) {
					return HEAP32[this.get_base_ptr() >> 2];
				}
				var adjusted = this.get_adjusted_ptr();
				if (adjusted !== 0) return adjusted;
				return this.get_base_ptr();
			};
			this.get_exception_info = function () {
				return new ExceptionInfo(this.get_base_ptr());
			};
			if (ptr === undefined) {
				this.ptr = _malloc(8);
				this.set_adjusted_ptr(0);
			} else {
				this.ptr = ptr;
			}
		}
		var exceptionCaught = [];
		function exception_addRef(info) {
			info.add_ref();
		}
		var uncaughtExceptionCount = 0;
		function ___cxa_begin_catch(ptr) {
			var catchInfo = new CatchInfo(ptr);
			var info = catchInfo.get_exception_info();
			if (!info.get_caught()) {
				info.set_caught(true);
				uncaughtExceptionCount--;
			}
			info.set_rethrown(false);
			exceptionCaught.push(catchInfo);
			exception_addRef(info);
			return catchInfo.get_exception_ptr();
		}
		var exceptionLast = 0;
		function ___cxa_free_exception(ptr) {
			try {
				return _free(new ExceptionInfo(ptr).ptr);
			} catch (e) {}
		}
		function exception_decRef(info) {
			if (info.release_ref() && !info.get_rethrown()) {
				var destructor = info.get_destructor();
				if (destructor) {
					wasmTable.get(destructor)(info.excPtr);
				}
				___cxa_free_exception(info.excPtr);
			}
		}
		function ___cxa_end_catch() {
			_setThrew(0);
			var catchInfo = exceptionCaught.pop();
			exception_decRef(catchInfo.get_exception_info());
			catchInfo.free();
			exceptionLast = 0;
		}
		function ___resumeException(catchInfoPtr) {
			var catchInfo = new CatchInfo(catchInfoPtr);
			var ptr = catchInfo.get_base_ptr();
			if (!exceptionLast) {
				exceptionLast = ptr;
			}
			catchInfo.free();
			throw ptr;
		}
		function ___cxa_find_matching_catch_2() {
			var thrown = exceptionLast;
			if (!thrown) {
				setTempRet0(0 | 0);
				return 0 | 0;
			}
			var info = new ExceptionInfo(thrown);
			var thrownType = info.get_type();
			var catchInfo = new CatchInfo();
			catchInfo.set_base_ptr(thrown);
			if (!thrownType) {
				setTempRet0(0 | 0);
				return catchInfo.ptr | 0;
			}
			var typeArray = Array.prototype.slice.call(arguments);
			var stackTop = stackSave();
			var exceptionThrowBuf = stackAlloc(4);
			HEAP32[exceptionThrowBuf >> 2] = thrown;
			for (var i = 0; i < typeArray.length; i++) {
				var caughtType = typeArray[i];
				if (caughtType === 0 || caughtType === thrownType) {
					break;
				}
				if (___cxa_can_catch(caughtType, thrownType, exceptionThrowBuf)) {
					var adjusted = HEAP32[exceptionThrowBuf >> 2];
					if (thrown !== adjusted) {
						catchInfo.set_adjusted_ptr(adjusted);
					}
					setTempRet0(caughtType | 0);
					return catchInfo.ptr | 0;
				}
			}
			stackRestore(stackTop);
			setTempRet0(thrownType | 0);
			return catchInfo.ptr | 0;
		}
		function ___cxa_find_matching_catch_3() {
			var thrown = exceptionLast;
			if (!thrown) {
				setTempRet0(0 | 0);
				return 0 | 0;
			}
			var info = new ExceptionInfo(thrown);
			var thrownType = info.get_type();
			var catchInfo = new CatchInfo();
			catchInfo.set_base_ptr(thrown);
			if (!thrownType) {
				setTempRet0(0 | 0);
				return catchInfo.ptr | 0;
			}
			var typeArray = Array.prototype.slice.call(arguments);
			var stackTop = stackSave();
			var exceptionThrowBuf = stackAlloc(4);
			HEAP32[exceptionThrowBuf >> 2] = thrown;
			for (var i = 0; i < typeArray.length; i++) {
				var caughtType = typeArray[i];
				if (caughtType === 0 || caughtType === thrownType) {
					break;
				}
				if (___cxa_can_catch(caughtType, thrownType, exceptionThrowBuf)) {
					var adjusted = HEAP32[exceptionThrowBuf >> 2];
					if (thrown !== adjusted) {
						catchInfo.set_adjusted_ptr(adjusted);
					}
					setTempRet0(caughtType | 0);
					return catchInfo.ptr | 0;
				}
			}
			stackRestore(stackTop);
			setTempRet0(thrownType | 0);
			return catchInfo.ptr | 0;
		}
		function ___cxa_find_matching_catch_4() {
			var thrown = exceptionLast;
			if (!thrown) {
				setTempRet0(0 | 0);
				return 0 | 0;
			}
			var info = new ExceptionInfo(thrown);
			var thrownType = info.get_type();
			var catchInfo = new CatchInfo();
			catchInfo.set_base_ptr(thrown);
			if (!thrownType) {
				setTempRet0(0 | 0);
				return catchInfo.ptr | 0;
			}
			var typeArray = Array.prototype.slice.call(arguments);
			var stackTop = stackSave();
			var exceptionThrowBuf = stackAlloc(4);
			HEAP32[exceptionThrowBuf >> 2] = thrown;
			for (var i = 0; i < typeArray.length; i++) {
				var caughtType = typeArray[i];
				if (caughtType === 0 || caughtType === thrownType) {
					break;
				}
				if (___cxa_can_catch(caughtType, thrownType, exceptionThrowBuf)) {
					var adjusted = HEAP32[exceptionThrowBuf >> 2];
					if (thrown !== adjusted) {
						catchInfo.set_adjusted_ptr(adjusted);
					}
					setTempRet0(caughtType | 0);
					return catchInfo.ptr | 0;
				}
			}
			stackRestore(stackTop);
			setTempRet0(thrownType | 0);
			return catchInfo.ptr | 0;
		}
		function ___cxa_rethrow() {
			var catchInfo = exceptionCaught.pop();
			if (!catchInfo) {
				abort('no exception to throw');
			}
			var info = catchInfo.get_exception_info();
			var ptr = catchInfo.get_base_ptr();
			if (!info.get_rethrown()) {
				exceptionCaught.push(catchInfo);
				info.set_rethrown(true);
				info.set_caught(false);
				uncaughtExceptionCount++;
			} else {
				catchInfo.free();
			}
			exceptionLast = ptr;
			throw ptr;
		}
		function ___cxa_throw(ptr, type, destructor) {
			var info = new ExceptionInfo(ptr);
			info.init(type, destructor);
			exceptionLast = ptr;
			uncaughtExceptionCount++;
			throw ptr;
		}
		function ___cxa_uncaught_exceptions() {
			return uncaughtExceptionCount;
		}
		function _tzset() {
			if (_tzset.called) return;
			_tzset.called = true;
			var currentYear = new Date().getFullYear();
			var winter = new Date(currentYear, 0, 1);
			var summer = new Date(currentYear, 6, 1);
			var winterOffset = winter.getTimezoneOffset();
			var summerOffset = summer.getTimezoneOffset();
			var stdTimezoneOffset = Math.max(winterOffset, summerOffset);
			HEAP32[__get_timezone() >> 2] = stdTimezoneOffset * 60;
			HEAP32[__get_daylight() >> 2] = Number(winterOffset != summerOffset);
			function extractZone(date) {
				var match = date.toTimeString().match(/\(([A-Za-z ]+)\)$/);
				return match ? match[1] : 'GMT';
			}
			var winterName = extractZone(winter);
			var summerName = extractZone(summer);
			var winterNamePtr = allocateUTF8(winterName);
			var summerNamePtr = allocateUTF8(summerName);
			if (summerOffset < winterOffset) {
				HEAP32[__get_tzname() >> 2] = winterNamePtr;
				HEAP32[(__get_tzname() + 4) >> 2] = summerNamePtr;
			} else {
				HEAP32[__get_tzname() >> 2] = summerNamePtr;
				HEAP32[(__get_tzname() + 4) >> 2] = winterNamePtr;
			}
		}
		function _localtime_r(time, tmPtr) {
			_tzset();
			var date = new Date(HEAP32[time >> 2] * 1e3);
			HEAP32[tmPtr >> 2] = date.getSeconds();
			HEAP32[(tmPtr + 4) >> 2] = date.getMinutes();
			HEAP32[(tmPtr + 8) >> 2] = date.getHours();
			HEAP32[(tmPtr + 12) >> 2] = date.getDate();
			HEAP32[(tmPtr + 16) >> 2] = date.getMonth();
			HEAP32[(tmPtr + 20) >> 2] = date.getFullYear() - 1900;
			HEAP32[(tmPtr + 24) >> 2] = date.getDay();
			var start = new Date(date.getFullYear(), 0, 1);
			var yday = ((date.getTime() - start.getTime()) / (1e3 * 60 * 60 * 24)) | 0;
			HEAP32[(tmPtr + 28) >> 2] = yday;
			HEAP32[(tmPtr + 36) >> 2] = -(date.getTimezoneOffset() * 60);
			var summerOffset = new Date(date.getFullYear(), 6, 1).getTimezoneOffset();
			var winterOffset = start.getTimezoneOffset();
			var dst = (summerOffset != winterOffset && date.getTimezoneOffset() == Math.min(winterOffset, summerOffset)) | 0;
			HEAP32[(tmPtr + 32) >> 2] = dst;
			var zonePtr = HEAP32[(__get_tzname() + (dst ? 4 : 0)) >> 2];
			HEAP32[(tmPtr + 40) >> 2] = zonePtr;
			return tmPtr;
		}
		function ___localtime_r(a0, a1) {
			return _localtime_r(a0, a1);
		}
		function _abort() {
			abort();
		}
		var _emscripten_get_now;
		if (ENVIRONMENT_IS_NODE) {
			_emscripten_get_now = function () {
				var t = process['hrtime']();
				return t[0] * 1e3 + t[1] / 1e6;
			};
		} else if (typeof dateNow !== 'undefined') {
			_emscripten_get_now = dateNow;
		} else
			_emscripten_get_now = function () {
				return performance.now();
			};
		var _emscripten_get_now_is_monotonic = true;
		function setErrNo(value) {
			HEAP32[___errno_location() >> 2] = value;
			return value;
		}
		function _clock_gettime(clk_id, tp) {
			var now;
			if (clk_id === 0) {
				now = Date.now();
			} else if ((clk_id === 1 || clk_id === 4) && _emscripten_get_now_is_monotonic) {
				now = _emscripten_get_now();
			} else {
				setErrNo(28);
				return -1;
			}
			HEAP32[tp >> 2] = (now / 1e3) | 0;
			HEAP32[(tp + 4) >> 2] = ((now % 1e3) * 1e3 * 1e3) | 0;
			return 0;
		}
		function _emscripten_memcpy_big(dest, src, num) {
			HEAPU8.copyWithin(dest, src, src + num);
		}
		function abortOnCannotGrowMemory(requestedSize) {
			abort('OOM');
		}
		function _emscripten_resize_heap(requestedSize) {
			abortOnCannotGrowMemory(requestedSize);
		}
		var ENV = {};
		function getExecutableName() {
			return thisProgram || './this.program';
		}
		function getEnvStrings() {
			if (!getEnvStrings.strings) {
				var lang = ((typeof navigator === 'object' && navigator.languages && navigator.languages[0]) || 'C').replace('-', '_') + '.UTF-8';
				var env = { USER: 'web_user', LOGNAME: 'web_user', PATH: '/', PWD: '/', HOME: '/home/web_user', LANG: lang, _: getExecutableName() };
				for (var x in ENV) {
					env[x] = ENV[x];
				}
				var strings = [];
				for (var x in env) {
					strings.push(x + '=' + env[x]);
				}
				getEnvStrings.strings = strings;
			}
			return getEnvStrings.strings;
		}
		var SYSCALLS = {
			mappings: {},
			buffers: [null, [], []],
			printChar: function (stream, curr) {
				var buffer = SYSCALLS.buffers[stream];
				if (curr === 0 || curr === 10) {
					(stream === 1 ? out : err)(UTF8ArrayToString(buffer, 0));
					buffer.length = 0;
				} else {
					buffer.push(curr);
				}
			},
			varargs: undefined,
			get: function () {
				SYSCALLS.varargs += 4;
				var ret = HEAP32[(SYSCALLS.varargs - 4) >> 2];
				return ret;
			},
			getStr: function (ptr) {
				var ret = UTF8ToString(ptr);
				return ret;
			},
			get64: function (low, high) {
				return low;
			},
		};
		function _environ_get(__environ, environ_buf) {
			var bufSize = 0;
			getEnvStrings().forEach(function (string, i) {
				var ptr = environ_buf + bufSize;
				HEAP32[(__environ + i * 4) >> 2] = ptr;
				writeAsciiToMemory(string, ptr);
				bufSize += string.length + 1;
			});
			return 0;
		}
		function _environ_sizes_get(penviron_count, penviron_buf_size) {
			var strings = getEnvStrings();
			HEAP32[penviron_count >> 2] = strings.length;
			var bufSize = 0;
			strings.forEach(function (string) {
				bufSize += string.length + 1;
			});
			HEAP32[penviron_buf_size >> 2] = bufSize;
			return 0;
		}
		function _fd_write(fd, iov, iovcnt, pnum) {
			var num = 0;
			for (var i = 0; i < iovcnt; i++) {
				var ptr = HEAP32[(iov + i * 8) >> 2];
				var len = HEAP32[(iov + (i * 8 + 4)) >> 2];
				for (var j = 0; j < len; j++) {
					SYSCALLS.printChar(fd, HEAPU8[ptr + j]);
				}
				num += len;
			}
			HEAP32[pnum >> 2] = num;
			return 0;
		}
		function _getTempRet0() {
			return getTempRet0() | 0;
		}
		function _js_clearscreen(canvasID, Color) {
			let canvas = document.getElementById(UTF8ToString(canvasID));
			const ctx = canvas.getContext('2d');
			if (!ctx) {
				console.log('ctx is null!');
				return false;
			}
			ctx.beginPath();
			ctx.clearRect(0, 0, canvas.width, canvas.height);
			ctx.fillStyle = UTF8ToString(Color);
			ctx.fillRect(0, 0, canvas.width, canvas.height);
			ctx.closePath();
			return true;
		}
		function _js_draw_characters(canvasID, FontSize, FontColor, CharactersText, LocationX, LocationY, Angle) {
			let canvas = document.getElementById(UTF8ToString(canvasID));
			const ctx = canvas.getContext('2d');
			if (!ctx) {
				console.log('ctx is null!');
				return false;
			}
			ctx.font = UTF8ToString(FontSize);
			ctx.fillStyle = UTF8ToString(FontColor);
			if (Angle < 0.001 && Angle > -0.001) {
				ctx.fillText(UTF8ToString(CharactersText), LocationX, LocationY);
				return true;
			} else {
				ctx.translate(LocationX, LocationY);
				let AngleRad = (-Angle * Math.PI) / 180;
				ctx.rotate(AngleRad);
				ctx.fillText(UTF8ToString(CharactersText), 0, 0);
				ctx.rotate(-AngleRad);
				ctx.translate(-LocationX, -LocationY);
				return true;
			}
		}
		function _js_draw_ellipse(canvasID, DashType1, DashType2, LineWidth, LineColor, FillingColor, CenterX, CenterY, RadiusX, RadiusY) {
			let canvas = document.getElementById(UTF8ToString(canvasID));
			const ctx = canvas.getContext('2d');
			if (!ctx) {
				console.log('ctx is null!');
				return false;
			}
			ctx.beginPath();
			ctx.lineWidth = LineWidth;
			ctx.strokeStyle = UTF8ToString(LineColor);
			ctx.setLineDash([DashType1, DashType2]);
			ctx.ellipse(CenterX, CenterY, RadiusX, RadiusY, 0, 0, 2 * Math.PI);
			ctx.stroke();
			if (0 !== FillingColor) {
				ctx.fillStyle = UTF8ToString(FillingColor);
				ctx.fill();
			}
			ctx.setLineDash([10, 0]);
			ctx.closePath();
			return true;
		}
		function _js_draw_init_2d(canvasID) {
			let canvas = document.getElementById(UTF8ToString(canvasID));
			if (!canvas) {
				console.log('js_draw_init_2d canvas is null');
				return false;
			}
			return true;
		}
		function _js_draw_lines(canvasID, DashType1, DashType2, LineWidth, LineColor, LineBeginX, LineBeginY, LineEndX, LineEndY) {
			let canvas = document.getElementById(UTF8ToString(canvasID));
			const ctx = canvas.getContext('2d');
			if (!ctx) {
				console.log('ctx is null!');
				return false;
			}
			ctx.beginPath();
			ctx.moveTo(LineBeginX, LineBeginY);
			ctx.lineTo(LineEndX, LineEndY);
			ctx.lineWidth = LineWidth;
			ctx.strokeStyle = UTF8ToString(LineColor);
			ctx.setLineDash([DashType1, DashType2]);
			ctx.stroke();
			ctx.setLineDash([10, 0]);
			ctx.closePath();
			return true;
		}
		function _js_get_win_height(canvasID) {
			let canvas = document.getElementById(UTF8ToString(canvasID));
			if (canvas) {
				return canvas.height;
			} else {
				console.log('canvas.height:0');
				return 0;
			}
		}
		function _js_get_win_width(canvasID) {
			let canvas = document.getElementById(UTF8ToString(canvasID));
			if (canvas) {
				return canvas.width;
			} else {
				console.log('canvas.width:0');
				return 0;
			}
		}
		function _llvm_eh_typeid_for(type) {
			return type;
		}
		function _setTempRet0($i) {
			setTempRet0($i | 0);
		}
		function __isLeapYear(year) {
			return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
		}
		function __arraySum(array, index) {
			var sum = 0;
			for (var i = 0; i <= index; sum += array[i++]) {}
			return sum;
		}
		var __MONTH_DAYS_LEAP = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
		var __MONTH_DAYS_REGULAR = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
		function __addDays(date, days) {
			var newDate = new Date(date.getTime());
			while (days > 0) {
				var leap = __isLeapYear(newDate.getFullYear());
				var currentMonth = newDate.getMonth();
				var daysInCurrentMonth = (leap ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR)[currentMonth];
				if (days > daysInCurrentMonth - newDate.getDate()) {
					days -= daysInCurrentMonth - newDate.getDate() + 1;
					newDate.setDate(1);
					if (currentMonth < 11) {
						newDate.setMonth(currentMonth + 1);
					} else {
						newDate.setMonth(0);
						newDate.setFullYear(newDate.getFullYear() + 1);
					}
				} else {
					newDate.setDate(newDate.getDate() + days);
					return newDate;
				}
			}
			return newDate;
		}
		function _strftime(s, maxsize, format, tm) {
			var tm_zone = HEAP32[(tm + 40) >> 2];
			var date = {
				tm_sec: HEAP32[tm >> 2],
				tm_min: HEAP32[(tm + 4) >> 2],
				tm_hour: HEAP32[(tm + 8) >> 2],
				tm_mday: HEAP32[(tm + 12) >> 2],
				tm_mon: HEAP32[(tm + 16) >> 2],
				tm_year: HEAP32[(tm + 20) >> 2],
				tm_wday: HEAP32[(tm + 24) >> 2],
				tm_yday: HEAP32[(tm + 28) >> 2],
				tm_isdst: HEAP32[(tm + 32) >> 2],
				tm_gmtoff: HEAP32[(tm + 36) >> 2],
				tm_zone: tm_zone ? UTF8ToString(tm_zone) : '',
			};
			var pattern = UTF8ToString(format);
			var EXPANSION_RULES_1 = {
				'%c': '%a %b %d %H:%M:%S %Y',
				'%D': '%m/%d/%y',
				'%F': '%Y-%m-%d',
				'%h': '%b',
				'%r': '%I:%M:%S %p',
				'%R': '%H:%M',
				'%T': '%H:%M:%S',
				'%x': '%m/%d/%y',
				'%X': '%H:%M:%S',
				'%Ec': '%c',
				'%EC': '%C',
				'%Ex': '%m/%d/%y',
				'%EX': '%H:%M:%S',
				'%Ey': '%y',
				'%EY': '%Y',
				'%Od': '%d',
				'%Oe': '%e',
				'%OH': '%H',
				'%OI': '%I',
				'%Om': '%m',
				'%OM': '%M',
				'%OS': '%S',
				'%Ou': '%u',
				'%OU': '%U',
				'%OV': '%V',
				'%Ow': '%w',
				'%OW': '%W',
				'%Oy': '%y',
			};
			for (var rule in EXPANSION_RULES_1) {
				pattern = pattern.replace(new RegExp(rule, 'g'), EXPANSION_RULES_1[rule]);
			}
			var WEEKDAYS = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
			var MONTHS = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'];
			function leadingSomething(value, digits, character) {
				var str = typeof value === 'number' ? value.toString() : value || '';
				while (str.length < digits) {
					str = character[0] + str;
				}
				return str;
			}
			function leadingNulls(value, digits) {
				return leadingSomething(value, digits, '0');
			}
			function compareByDay(date1, date2) {
				function sgn(value) {
					return value < 0 ? -1 : value > 0 ? 1 : 0;
				}
				var compare;
				if ((compare = sgn(date1.getFullYear() - date2.getFullYear())) === 0) {
					if ((compare = sgn(date1.getMonth() - date2.getMonth())) === 0) {
						compare = sgn(date1.getDate() - date2.getDate());
					}
				}
				return compare;
			}
			function getFirstWeekStartDate(janFourth) {
				switch (janFourth.getDay()) {
					case 0:
						return new Date(janFourth.getFullYear() - 1, 11, 29);
					case 1:
						return janFourth;
					case 2:
						return new Date(janFourth.getFullYear(), 0, 3);
					case 3:
						return new Date(janFourth.getFullYear(), 0, 2);
					case 4:
						return new Date(janFourth.getFullYear(), 0, 1);
					case 5:
						return new Date(janFourth.getFullYear() - 1, 11, 31);
					case 6:
						return new Date(janFourth.getFullYear() - 1, 11, 30);
				}
			}
			function getWeekBasedYear(date) {
				var thisDate = __addDays(new Date(date.tm_year + 1900, 0, 1), date.tm_yday);
				var janFourthThisYear = new Date(thisDate.getFullYear(), 0, 4);
				var janFourthNextYear = new Date(thisDate.getFullYear() + 1, 0, 4);
				var firstWeekStartThisYear = getFirstWeekStartDate(janFourthThisYear);
				var firstWeekStartNextYear = getFirstWeekStartDate(janFourthNextYear);
				if (compareByDay(firstWeekStartThisYear, thisDate) <= 0) {
					if (compareByDay(firstWeekStartNextYear, thisDate) <= 0) {
						return thisDate.getFullYear() + 1;
					} else {
						return thisDate.getFullYear();
					}
				} else {
					return thisDate.getFullYear() - 1;
				}
			}
			var EXPANSION_RULES_2 = {
				'%a': function (date) {
					return WEEKDAYS[date.tm_wday].substring(0, 3);
				},
				'%A': function (date) {
					return WEEKDAYS[date.tm_wday];
				},
				'%b': function (date) {
					return MONTHS[date.tm_mon].substring(0, 3);
				},
				'%B': function (date) {
					return MONTHS[date.tm_mon];
				},
				'%C': function (date) {
					var year = date.tm_year + 1900;
					return leadingNulls((year / 100) | 0, 2);
				},
				'%d': function (date) {
					return leadingNulls(date.tm_mday, 2);
				},
				'%e': function (date) {
					return leadingSomething(date.tm_mday, 2, ' ');
				},
				'%g': function (date) {
					return getWeekBasedYear(date).toString().substring(2);
				},
				'%G': function (date) {
					return getWeekBasedYear(date);
				},
				'%H': function (date) {
					return leadingNulls(date.tm_hour, 2);
				},
				'%I': function (date) {
					var twelveHour = date.tm_hour;
					if (twelveHour == 0) twelveHour = 12;
					else if (twelveHour > 12) twelveHour -= 12;
					return leadingNulls(twelveHour, 2);
				},
				'%j': function (date) {
					return leadingNulls(
						date.tm_mday + __arraySum(__isLeapYear(date.tm_year + 1900) ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR, date.tm_mon - 1),
						3
					);
				},
				'%m': function (date) {
					return leadingNulls(date.tm_mon + 1, 2);
				},
				'%M': function (date) {
					return leadingNulls(date.tm_min, 2);
				},
				'%n': function () {
					return '\n';
				},
				'%p': function (date) {
					if (date.tm_hour >= 0 && date.tm_hour < 12) {
						return 'AM';
					} else {
						return 'PM';
					}
				},
				'%S': function (date) {
					return leadingNulls(date.tm_sec, 2);
				},
				'%t': function () {
					return '\t';
				},
				'%u': function (date) {
					return date.tm_wday || 7;
				},
				'%U': function (date) {
					var janFirst = new Date(date.tm_year + 1900, 0, 1);
					var firstSunday = janFirst.getDay() === 0 ? janFirst : __addDays(janFirst, 7 - janFirst.getDay());
					var endDate = new Date(date.tm_year + 1900, date.tm_mon, date.tm_mday);
					if (compareByDay(firstSunday, endDate) < 0) {
						var februaryFirstUntilEndMonth =
							__arraySum(__isLeapYear(endDate.getFullYear()) ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR, endDate.getMonth() - 1) - 31;
						var firstSundayUntilEndJanuary = 31 - firstSunday.getDate();
						var days = firstSundayUntilEndJanuary + februaryFirstUntilEndMonth + endDate.getDate();
						return leadingNulls(Math.ceil(days / 7), 2);
					}
					return compareByDay(firstSunday, janFirst) === 0 ? '01' : '00';
				},
				'%V': function (date) {
					var janFourthThisYear = new Date(date.tm_year + 1900, 0, 4);
					var janFourthNextYear = new Date(date.tm_year + 1901, 0, 4);
					var firstWeekStartThisYear = getFirstWeekStartDate(janFourthThisYear);
					var firstWeekStartNextYear = getFirstWeekStartDate(janFourthNextYear);
					var endDate = __addDays(new Date(date.tm_year + 1900, 0, 1), date.tm_yday);
					if (compareByDay(endDate, firstWeekStartThisYear) < 0) {
						return '53';
					}
					if (compareByDay(firstWeekStartNextYear, endDate) <= 0) {
						return '01';
					}
					var daysDifference;
					if (firstWeekStartThisYear.getFullYear() < date.tm_year + 1900) {
						daysDifference = date.tm_yday + 32 - firstWeekStartThisYear.getDate();
					} else {
						daysDifference = date.tm_yday + 1 - firstWeekStartThisYear.getDate();
					}
					return leadingNulls(Math.ceil(daysDifference / 7), 2);
				},
				'%w': function (date) {
					return date.tm_wday;
				},
				'%W': function (date) {
					var janFirst = new Date(date.tm_year, 0, 1);
					var firstMonday = janFirst.getDay() === 1 ? janFirst : __addDays(janFirst, janFirst.getDay() === 0 ? 1 : 7 - janFirst.getDay() + 1);
					var endDate = new Date(date.tm_year + 1900, date.tm_mon, date.tm_mday);
					if (compareByDay(firstMonday, endDate) < 0) {
						var februaryFirstUntilEndMonth =
							__arraySum(__isLeapYear(endDate.getFullYear()) ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR, endDate.getMonth() - 1) - 31;
						var firstMondayUntilEndJanuary = 31 - firstMonday.getDate();
						var days = firstMondayUntilEndJanuary + februaryFirstUntilEndMonth + endDate.getDate();
						return leadingNulls(Math.ceil(days / 7), 2);
					}
					return compareByDay(firstMonday, janFirst) === 0 ? '01' : '00';
				},
				'%y': function (date) {
					return (date.tm_year + 1900).toString().substring(2);
				},
				'%Y': function (date) {
					return date.tm_year + 1900;
				},
				'%z': function (date) {
					var off = date.tm_gmtoff;
					var ahead = off >= 0;
					off = Math.abs(off) / 60;
					off = (off / 60) * 100 + (off % 60);
					return (ahead ? '+' : '-') + String('0000' + off).slice(-4);
				},
				'%Z': function (date) {
					return date.tm_zone;
				},
				'%%': function () {
					return '%';
				},
			};
			for (var rule in EXPANSION_RULES_2) {
				if (pattern.indexOf(rule) >= 0) {
					pattern = pattern.replace(new RegExp(rule, 'g'), EXPANSION_RULES_2[rule](date));
				}
			}
			var bytes = intArrayFromString(pattern, false);
			if (bytes.length > maxsize) {
				return 0;
			}
			writeArrayToMemory(bytes, s);
			return bytes.length - 1;
		}
		function _strftime_l(s, maxsize, format, tm) {
			return _strftime(s, maxsize, format, tm);
		}
		function intArrayFromString(stringy, dontAddNull, length) {
			var len = length > 0 ? length : lengthBytesUTF8(stringy) + 1;
			var u8array = new Array(len);
			var numBytesWritten = stringToUTF8Array(stringy, u8array, 0, u8array.length);
			if (dontAddNull) u8array.length = numBytesWritten;
			return u8array;
		}
		var asmLibraryArg = {
			B: ___assert_fail,
			o: ___cxa_allocate_exception,
			n: ___cxa_begin_catch,
			t: ___cxa_end_catch,
			c: ___cxa_find_matching_catch_2,
			g: ___cxa_find_matching_catch_3,
			r: ___cxa_find_matching_catch_4,
			q: ___cxa_free_exception,
			O: ___cxa_rethrow,
			w: ___cxa_throw,
			ia: ___cxa_uncaught_exceptions,
			U: ___localtime_r,
			e: ___resumeException,
			ja: _abort,
			S: _clock_gettime,
			P: _emscripten_memcpy_big,
			T: _emscripten_resize_heap,
			fa: _environ_get,
			ga: _environ_sizes_get,
			L: _fd_write,
			a: _getTempRet0,
			F: invoke_di,
			M: invoke_diii,
			N: invoke_fiii,
			p: invoke_i,
			d: invoke_ii,
			ca: invoke_iif,
			b: invoke_iii,
			h: invoke_iiii,
			G: invoke_iiiif,
			V: invoke_iiiifi,
			k: invoke_iiiii,
			da: invoke_iiiiid,
			H: invoke_iiiiif,
			x: invoke_iiiiii,
			z: invoke_iiiiiii,
			X: invoke_iiiiiiif,
			I: invoke_iiiiiiii,
			_: invoke_iiiiiiiiii,
			ha: invoke_iiiiiiiiiii,
			E: invoke_iiiiiiiiiiii,
			ba: invoke_iiiiiiiiiiiiiiiiii,
			Q: invoke_jiiii,
			j: invoke_v,
			l: invoke_vi,
			f: invoke_vii,
			i: invoke_viii,
			m: invoke_viiii,
			u: invoke_viiiii,
			y: invoke_viiiiii,
			s: invoke_viiiiiii,
			A: invoke_viiiiiiiii,
			C: invoke_viiiiiiiiii,
			D: invoke_viiiiiiiiiiiiiii,
			W: _js_clearscreen,
			Y: _js_draw_characters,
			Z: _js_draw_ellipse,
			aa: _js_draw_init_2d,
			$: _js_draw_lines,
			J: _js_get_win_height,
			K: _js_get_win_width,
			v: _llvm_eh_typeid_for,
			R: _setTempRet0,
			ea: _strftime_l,
		};
		var asm = createWasm();
		var ___wasm_call_ctors = (Module['___wasm_call_ctors'] = function () {
			return (___wasm_call_ctors = Module['___wasm_call_ctors'] = Module['asm']['la']).apply(null, arguments);
		});
		var _DRAW_Open = (Module['_DRAW_Open'] = function () {
			return (_DRAW_Open = Module['_DRAW_Open'] = Module['asm']['ma']).apply(null, arguments);
		});
		var _DRAW_Close = (Module['_DRAW_Close'] = function () {
			return (_DRAW_Close = Module['_DRAW_Close'] = Module['asm']['na']).apply(null, arguments);
		});
		var _DRAW_SetWebCanvas = (Module['_DRAW_SetWebCanvas'] = function () {
			return (_DRAW_SetWebCanvas = Module['_DRAW_SetWebCanvas'] = Module['asm']['oa']).apply(null, arguments);
		});
		var _DRAW_InputJsonData = (Module['_DRAW_InputJsonData'] = function () {
			return (_DRAW_InputJsonData = Module['_DRAW_InputJsonData'] = Module['asm']['pa']).apply(null, arguments);
		});
		var _DRAW_InputRuleData = (Module['_DRAW_InputRuleData'] = function () {
			return (_DRAW_InputRuleData = Module['_DRAW_InputRuleData'] = Module['asm']['qa']).apply(null, arguments);
		});
		var _DRAW_InputRuleDataEx = (Module['_DRAW_InputRuleDataEx'] = function () {
			return (_DRAW_InputRuleDataEx = Module['_DRAW_InputRuleDataEx'] = Module['asm']['ra']).apply(null, arguments);
		});
		var _DRAW_InputTrackData = (Module['_DRAW_InputTrackData'] = function () {
			return (_DRAW_InputTrackData = Module['_DRAW_InputTrackData'] = Module['asm']['sa']).apply(null, arguments);
		});
		var _DRAW_InputTrackDataEx2 = (Module['_DRAW_InputTrackDataEx2'] = function () {
			return (_DRAW_InputTrackDataEx2 = Module['_DRAW_InputTrackDataEx2'] = Module['asm']['ta']).apply(null, arguments);
		});
		var _DRAW_InputIVSData = (Module['_DRAW_InputIVSData'] = function () {
			return (_DRAW_InputIVSData = Module['_DRAW_InputIVSData'] = Module['asm']['ua']).apply(null, arguments);
		});
		var _DRAW_DrawByRenderHandle = (Module['_DRAW_DrawByRenderHandle'] = function () {
			return (_DRAW_DrawByRenderHandle = Module['_DRAW_DrawByRenderHandle'] = Module['asm']['va']).apply(null, arguments);
		});
		var _DRAW_SetLifeCount = (Module['_DRAW_SetLifeCount'] = function () {
			return (_DRAW_SetLifeCount = Module['_DRAW_SetLifeCount'] = Module['asm']['wa']).apply(null, arguments);
		});
		var _DRAW_SetEnable = (Module['_DRAW_SetEnable'] = function () {
			return (_DRAW_SetEnable = Module['_DRAW_SetEnable'] = Module['asm']['xa']).apply(null, arguments);
		});
		var _DRAW_SetPen = (Module['_DRAW_SetPen'] = function () {
			return (_DRAW_SetPen = Module['_DRAW_SetPen'] = Module['asm']['ya']).apply(null, arguments);
		});
		var _DRAW_Clean = (Module['_DRAW_Clean'] = function () {
			return (_DRAW_Clean = Module['_DRAW_Clean'] = Module['asm']['za']).apply(null, arguments);
		});
		var _DRAW_SetDrawSurfaceParam = (Module['_DRAW_SetDrawSurfaceParam'] = function () {
			return (_DRAW_SetDrawSurfaceParam = Module['_DRAW_SetDrawSurfaceParam'] = Module['asm']['Aa']).apply(null, arguments);
		});
		var ___errno_location = (Module['___errno_location'] = function () {
			return (___errno_location = Module['___errno_location'] = Module['asm']['Ba']).apply(null, arguments);
		});
		var __get_tzname = (Module['__get_tzname'] = function () {
			return (__get_tzname = Module['__get_tzname'] = Module['asm']['Ca']).apply(null, arguments);
		});
		var __get_daylight = (Module['__get_daylight'] = function () {
			return (__get_daylight = Module['__get_daylight'] = Module['asm']['Da']).apply(null, arguments);
		});
		var __get_timezone = (Module['__get_timezone'] = function () {
			return (__get_timezone = Module['__get_timezone'] = Module['asm']['Ea']).apply(null, arguments);
		});
		var stackSave = (Module['stackSave'] = function () {
			return (stackSave = Module['stackSave'] = Module['asm']['Fa']).apply(null, arguments);
		});
		var stackRestore = (Module['stackRestore'] = function () {
			return (stackRestore = Module['stackRestore'] = Module['asm']['Ga']).apply(null, arguments);
		});
		var stackAlloc = (Module['stackAlloc'] = function () {
			return (stackAlloc = Module['stackAlloc'] = Module['asm']['Ha']).apply(null, arguments);
		});
		var _setThrew = (Module['_setThrew'] = function () {
			return (_setThrew = Module['_setThrew'] = Module['asm']['Ia']).apply(null, arguments);
		});
		var ___cxa_can_catch = (Module['___cxa_can_catch'] = function () {
			return (___cxa_can_catch = Module['___cxa_can_catch'] = Module['asm']['Ja']).apply(null, arguments);
		});
		var ___cxa_is_pointer_type = (Module['___cxa_is_pointer_type'] = function () {
			return (___cxa_is_pointer_type = Module['___cxa_is_pointer_type'] = Module['asm']['Ka']).apply(null, arguments);
		});
		var _malloc = (Module['_malloc'] = function () {
			return (_malloc = Module['_malloc'] = Module['asm']['La']).apply(null, arguments);
		});
		var _free = (Module['_free'] = function () {
			return (_free = Module['_free'] = Module['asm']['Ma']).apply(null, arguments);
		});
		var dynCall_jiiii = (Module['dynCall_jiiii'] = function () {
			return (dynCall_jiiii = Module['dynCall_jiiii'] = Module['asm']['Oa']).apply(null, arguments);
		});
		function invoke_iii(index, a1, a2) {
			var sp = stackSave();
			try {
				return wasmTable.get(index)(a1, a2);
			} catch (e) {
				stackRestore(sp);
				if (e !== e + 0 && e !== 'longjmp') throw e;
				_setThrew(1, 0);
			}
		}
		function invoke_ii(index, a1) {
			var sp = stackSave();
			try {
				return wasmTable.get(index)(a1);
			} catch (e) {
				stackRestore(sp);
				if (e !== e + 0 && e !== 'longjmp') throw e;
				_setThrew(1, 0);
			}
		}
		function invoke_v(index) {
			var sp = stackSave();
			try {
				wasmTable.get(index)();
			} catch (e) {
				stackRestore(sp);
				if (e !== e + 0 && e !== 'longjmp') throw e;
				_setThrew(1, 0);
			}
		}
		function invoke_i(index) {
			var sp = stackSave();
			try {
				return wasmTable.get(index)();
			} catch (e) {
				stackRestore(sp);
				if (e !== e + 0 && e !== 'longjmp') throw e;
				_setThrew(1, 0);
			}
		}
		function invoke_vii(index, a1, a2) {
			var sp = stackSave();
			try {
				wasmTable.get(index)(a1, a2);
			} catch (e) {
				stackRestore(sp);
				if (e !== e + 0 && e !== 'longjmp') throw e;
				_setThrew(1, 0);
			}
		}
		function invoke_vi(index, a1) {
			var sp = stackSave();
			try {
				wasmTable.get(index)(a1);
			} catch (e) {
				stackRestore(sp);
				if (e !== e + 0 && e !== 'longjmp') throw e;
				_setThrew(1, 0);
			}
		}
		function invoke_viii(index, a1, a2, a3) {
			var sp = stackSave();
			try {
				wasmTable.get(index)(a1, a2, a3);
			} catch (e) {
				stackRestore(sp);
				if (e !== e + 0 && e !== 'longjmp') throw e;
				_setThrew(1, 0);
			}
		}
		function invoke_iiii(index, a1, a2, a3) {
			var sp = stackSave();
			try {
				return wasmTable.get(index)(a1, a2, a3);
			} catch (e) {
				stackRestore(sp);
				if (e !== e + 0 && e !== 'longjmp') throw e;
				_setThrew(1, 0);
			}
		}
		function invoke_viiiii(index, a1, a2, a3, a4, a5) {
			var sp = stackSave();
			try {
				wasmTable.get(index)(a1, a2, a3, a4, a5);
			} catch (e) {
				stackRestore(sp);
				if (e !== e + 0 && e !== 'longjmp') throw e;
				_setThrew(1, 0);
			}
		}
		function invoke_iiiiii(index, a1, a2, a3, a4, a5) {
			var sp = stackSave();
			try {
				return wasmTable.get(index)(a1, a2, a3, a4, a5);
			} catch (e) {
				stackRestore(sp);
				if (e !== e + 0 && e !== 'longjmp') throw e;
				_setThrew(1, 0);
			}
		}
		function invoke_viiii(index, a1, a2, a3, a4) {
			var sp = stackSave();
			try {
				wasmTable.get(index)(a1, a2, a3, a4);
			} catch (e) {
				stackRestore(sp);
				if (e !== e + 0 && e !== 'longjmp') throw e;
				_setThrew(1, 0);
			}
		}
		function invoke_iiiii(index, a1, a2, a3, a4) {
			var sp = stackSave();
			try {
				return wasmTable.get(index)(a1, a2, a3, a4);
			} catch (e) {
				stackRestore(sp);
				if (e !== e + 0 && e !== 'longjmp') throw e;
				_setThrew(1, 0);
			}
		}
		function invoke_fiii(index, a1, a2, a3) {
			var sp = stackSave();
			try {
				return wasmTable.get(index)(a1, a2, a3);
			} catch (e) {
				stackRestore(sp);
				if (e !== e + 0 && e !== 'longjmp') throw e;
				_setThrew(1, 0);
			}
		}
		function invoke_diii(index, a1, a2, a3) {
			var sp = stackSave();
			try {
				return wasmTable.get(index)(a1, a2, a3);
			} catch (e) {
				stackRestore(sp);
				if (e !== e + 0 && e !== 'longjmp') throw e;
				_setThrew(1, 0);
			}
		}
		function invoke_viiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9) {
			var sp = stackSave();
			try {
				wasmTable.get(index)(a1, a2, a3, a4, a5, a6, a7, a8, a9);
			} catch (e) {
				stackRestore(sp);
				if (e !== e + 0 && e !== 'longjmp') throw e;
				_setThrew(1, 0);
			}
		}
		function invoke_iiiiiiii(index, a1, a2, a3, a4, a5, a6, a7) {
			var sp = stackSave();
			try {
				return wasmTable.get(index)(a1, a2, a3, a4, a5, a6, a7);
			} catch (e) {
				stackRestore(sp);
				if (e !== e + 0 && e !== 'longjmp') throw e;
				_setThrew(1, 0);
			}
		}
		function invoke_iiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {
			var sp = stackSave();
			try {
				return wasmTable.get(index)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
			} catch (e) {
				stackRestore(sp);
				if (e !== e + 0 && e !== 'longjmp') throw e;
				_setThrew(1, 0);
			}
		}
		function invoke_viiiiiii(index, a1, a2, a3, a4, a5, a6, a7) {
			var sp = stackSave();
			try {
				wasmTable.get(index)(a1, a2, a3, a4, a5, a6, a7);
			} catch (e) {
				stackRestore(sp);
				if (e !== e + 0 && e !== 'longjmp') throw e;
				_setThrew(1, 0);
			}
		}
		function invoke_iiiiiii(index, a1, a2, a3, a4, a5, a6) {
			var sp = stackSave();
			try {
				return wasmTable.get(index)(a1, a2, a3, a4, a5, a6);
			} catch (e) {
				stackRestore(sp);
				if (e !== e + 0 && e !== 'longjmp') throw e;
				_setThrew(1, 0);
			}
		}
		function invoke_iiiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) {
			var sp = stackSave();
			try {
				return wasmTable.get(index)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
			} catch (e) {
				stackRestore(sp);
				if (e !== e + 0 && e !== 'longjmp') throw e;
				_setThrew(1, 0);
			}
		}
		function invoke_viiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {
			var sp = stackSave();
			try {
				wasmTable.get(index)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
			} catch (e) {
				stackRestore(sp);
				if (e !== e + 0 && e !== 'longjmp') throw e;
				_setThrew(1, 0);
			}
		}
		function invoke_viiiiiiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15) {
			var sp = stackSave();
			try {
				wasmTable.get(index)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
			} catch (e) {
				stackRestore(sp);
				if (e !== e + 0 && e !== 'longjmp') throw e;
				_setThrew(1, 0);
			}
		}
		function invoke_viiiiii(index, a1, a2, a3, a4, a5, a6) {
			var sp = stackSave();
			try {
				wasmTable.get(index)(a1, a2, a3, a4, a5, a6);
			} catch (e) {
				stackRestore(sp);
				if (e !== e + 0 && e !== 'longjmp') throw e;
				_setThrew(1, 0);
			}
		}
		function invoke_iiiiid(index, a1, a2, a3, a4, a5) {
			var sp = stackSave();
			try {
				return wasmTable.get(index)(a1, a2, a3, a4, a5);
			} catch (e) {
				stackRestore(sp);
				if (e !== e + 0 && e !== 'longjmp') throw e;
				_setThrew(1, 0);
			}
		}
		function invoke_iif(index, a1, a2) {
			var sp = stackSave();
			try {
				return wasmTable.get(index)(a1, a2);
			} catch (e) {
				stackRestore(sp);
				if (e !== e + 0 && e !== 'longjmp') throw e;
				_setThrew(1, 0);
			}
		}
		function invoke_iiiiiiiiiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17) {
			var sp = stackSave();
			try {
				return wasmTable.get(index)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17);
			} catch (e) {
				stackRestore(sp);
				if (e !== e + 0 && e !== 'longjmp') throw e;
				_setThrew(1, 0);
			}
		}
		function invoke_iiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9) {
			var sp = stackSave();
			try {
				return wasmTable.get(index)(a1, a2, a3, a4, a5, a6, a7, a8, a9);
			} catch (e) {
				stackRestore(sp);
				if (e !== e + 0 && e !== 'longjmp') throw e;
				_setThrew(1, 0);
			}
		}
		function invoke_iiiiif(index, a1, a2, a3, a4, a5) {
			var sp = stackSave();
			try {
				return wasmTable.get(index)(a1, a2, a3, a4, a5);
			} catch (e) {
				stackRestore(sp);
				if (e !== e + 0 && e !== 'longjmp') throw e;
				_setThrew(1, 0);
			}
		}
		function invoke_iiiiiiif(index, a1, a2, a3, a4, a5, a6, a7) {
			var sp = stackSave();
			try {
				return wasmTable.get(index)(a1, a2, a3, a4, a5, a6, a7);
			} catch (e) {
				stackRestore(sp);
				if (e !== e + 0 && e !== 'longjmp') throw e;
				_setThrew(1, 0);
			}
		}
		function invoke_iiiifi(index, a1, a2, a3, a4, a5) {
			var sp = stackSave();
			try {
				return wasmTable.get(index)(a1, a2, a3, a4, a5);
			} catch (e) {
				stackRestore(sp);
				if (e !== e + 0 && e !== 'longjmp') throw e;
				_setThrew(1, 0);
			}
		}
		function invoke_iiiif(index, a1, a2, a3, a4) {
			var sp = stackSave();
			try {
				return wasmTable.get(index)(a1, a2, a3, a4);
			} catch (e) {
				stackRestore(sp);
				if (e !== e + 0 && e !== 'longjmp') throw e;
				_setThrew(1, 0);
			}
		}
		function invoke_di(index, a1) {
			var sp = stackSave();
			try {
				return wasmTable.get(index)(a1);
			} catch (e) {
				stackRestore(sp);
				if (e !== e + 0 && e !== 'longjmp') throw e;
				_setThrew(1, 0);
			}
		}
		function invoke_jiiii(index, a1, a2, a3, a4) {
			var sp = stackSave();
			try {
				return dynCall_jiiii(index, a1, a2, a3, a4);
			} catch (e) {
				stackRestore(sp);
				if (e !== e + 0 && e !== 'longjmp') throw e;
				_setThrew(1, 0);
			}
		}
		Module['writeArrayToMemory'] = writeArrayToMemory;
		Module['allocateUTF8'] = allocateUTF8;
		var calledRun;
		function ExitStatus(status) {
			this.name = 'ExitStatus';
			this.message = 'Program terminated with exit(' + status + ')';
			this.status = status;
		}
		dependenciesFulfilled = function runCaller() {
			if (!calledRun) run();
			if (!calledRun) dependenciesFulfilled = runCaller;
		};
		function run(args) {
			args = args || arguments_;
			if (runDependencies > 0) {
				return;
			}
			preRun();
			if (runDependencies > 0) {
				return;
			}
			function doRun() {
				if (calledRun) return;
				calledRun = true;
				Module['calledRun'] = true;
				if (ABORT) return;
				initRuntime();
				preMain();
				readyPromiseResolve(Module);
				if (Module['onRuntimeInitialized']) Module['onRuntimeInitialized']();
				postRun();
			}
			if (Module['setStatus']) {
				Module['setStatus']('Running...');
				setTimeout(function () {
					setTimeout(function () {
						Module['setStatus']('');
					}, 1);
					doRun();
				}, 1);
			} else {
				doRun();
			}
		}
		Module['run'] = run;
		if (Module['preInit']) {
			if (typeof Module['preInit'] == 'function') Module['preInit'] = [Module['preInit']];
			while (Module['preInit'].length > 0) {
				Module['preInit'].pop()();
			}
		}
		run();

		return IVSDrawer_Module.ready;
	};
})();
if (typeof exports === 'object' && typeof module === 'object') module.exports = IVSDrawer_Module;
else if (typeof define === 'function' && define['amd'])
	define([], function () {
		return IVSDrawer_Module;
	});
else if (typeof exports === 'object') exports['IVSDrawer_Module'] = IVSDrawer_Module;
